382 lines
11 KiB
Go
Raw Permalink Normal View History

2019-04-22 02:59:20 +00:00
package material
import (
"context"
"encoding/json"
"fmt"
appMdl "go-common/app/interface/main/creative/model/app"
"go-common/app/interface/main/creative/model/music"
"go-common/library/log"
"go-common/library/xstr"
"strings"
"time"
)
const (
_basicSQL = "SELECT mtime,id,name,rank,extra,platform,build,type FROM material WHERE type in (%s) and state = 0 order by type asc, rank asc"
_FiltersSQL = "SELECT mtime,id,name,rank,extra,platform,build FROM material WHERE type=2 and state = 0 order by rank asc "
_CategoryBindSQL = "SELECT a.new, a.type, a.name as cname,a.rank as crank,b.index as brank,b.material_id as mid, b.category_id as cid from material_category a join material_with_category b where a.id = b.category_id and a.state=0 and b.state=0 and a.type =%d order by a.rank asc, b.index asc"
_VstickersSQL = "SELECT mtime,id,name,rank,extra,platform,build FROM material WHERE type=7 and state = 0 order by rank asc "
_CooperatesSQL = "SELECT mtime,id,name,rank,extra,platform,build FROM material WHERE type=9 and state = 0 order by rank asc "
)
var basicTypes = []int64{
int64(appMdl.TypeSubtitle),
int64(appMdl.TypeFont),
int64(appMdl.TypeHotWord),
int64(appMdl.TypeSticker),
int64(appMdl.TypeIntro),
int64(appMdl.TypeTransition),
int64(appMdl.TypeTheme),
}
// Basic fn
func (d *Dao) Basic(c context.Context) (basicMap map[string]interface{}, err error) {
rows, err := d.db.Query(c, fmt.Sprintf(_basicSQL, xstr.JoinInts(basicTypes)))
if err != nil {
log.Error("mysqlDB.Query error(%v)", err)
return
}
defer rows.Close()
basicMap = make(map[string]interface{})
var (
subs = make([]*music.Subtitle, 0)
fons = make([]*music.Font, 0)
hots = make([]*music.Hotword, 0)
stis = make([]*music.Sticker, 0)
ints = make([]*music.Intro, 0)
trans = make([]*music.Transition, 0)
themes = make([]*music.Theme, 0)
)
basicMap["subs"] = subs
basicMap["fons"] = fons
basicMap["hots"] = hots
basicMap["stis"] = stis
basicMap["ints"] = ints
basicMap["trans"] = trans
basicMap["themes"] = themes
for rows.Next() {
b := &music.Basic{
Material: music.Material{},
}
if err = rows.Scan(&b.MTime, &b.ID, &b.Name, &b.Rank, &b.Extra, &b.Material.Platform, &b.Material.Build, &b.Material.Type); err != nil {
log.Error("row.Scan error(%v)", err)
return
}
var extra *struct {
Cover string `json:"cover"`
DownloadURL string `json:"download_url"`
Max int `json:"max"`
SubType int64 `json:"sub_type"`
Tip string `json:"tip"`
White int8 `json:"white_list"`
TagsStr string `json:"tags"`
}
if err = json.Unmarshal([]byte(b.Extra), &extra); err != nil {
log.Error("json.Unmarshal extra failed error(%v)", err)
continue
}
b.Cover = extra.Cover
b.DownloadURL = extra.DownloadURL
b.Max = extra.Max
b.White = extra.White
if len(b.Material.Build) > 0 {
var buildComps []*music.BuildComp
if err = json.Unmarshal([]byte(b.Build), &buildComps); err != nil {
log.Error("json.Unmarshal buildComps failed error(%v)", err)
continue
}
b.Material.BuildComps = buildComps
}
if b.MTime.Time().AddDate(0, 0, 7).Unix() >= time.Now().Unix() {
b.New = 1
}
if len(extra.TagsStr) > 0 {
b.Tags = append(b.Tags, strings.Split(extra.TagsStr, ",")...)
}
log.Info("b info v(%+v)", b)
switch b.Material.Type {
case appMdl.TypeSubtitle:
subs = append(subs, &music.Subtitle{
ID: b.ID,
Name: b.Name,
Cover: b.Cover,
DownloadURL: b.DownloadURL,
Rank: b.Rank,
Max: b.Max,
Material: b.Material,
New: b.New,
Tags: b.Tags,
MTime: b.MTime,
})
case appMdl.TypeFont:
fons = append(fons, &music.Font{
ID: b.ID,
Name: b.Name,
Cover: b.Cover,
DownloadURL: b.DownloadURL,
Rank: b.Rank,
Material: b.Material,
New: b.New,
Tags: b.Tags,
MTime: b.MTime,
})
case appMdl.TypeHotWord:
hots = append(hots, &music.Hotword{
ID: b.ID,
Name: b.Name,
Cover: b.Cover,
DownloadURL: b.DownloadURL,
Rank: b.Rank,
Material: b.Material,
New: b.New,
Tags: b.Tags,
MTime: b.MTime,
})
case appMdl.TypeSticker:
stis = append(stis, &music.Sticker{
ID: b.ID,
Name: b.Name,
Cover: b.Cover,
DownloadURL: b.DownloadURL,
Rank: b.Rank,
Material: b.Material,
SubType: extra.SubType,
Tip: extra.Tip,
New: b.New,
Tags: b.Tags,
MTime: b.MTime,
})
case appMdl.TypeTheme:
themes = append(themes, &music.Theme{
ID: b.ID,
Name: b.Name,
Cover: b.Cover,
DownloadURL: b.DownloadURL,
Rank: b.Rank,
Material: b.Material,
New: b.New,
Tags: b.Tags,
MTime: b.MTime,
})
case appMdl.TypeIntro:
ints = append(ints, &music.Intro{
ID: b.ID,
Name: b.Name,
Cover: b.Cover,
DownloadURL: b.DownloadURL,
Rank: b.Rank,
Material: b.Material,
New: b.New,
Tags: b.Tags,
MTime: b.MTime,
})
case appMdl.TypeTransition:
trans = append(trans, &music.Transition{
ID: b.ID,
Name: b.Name,
Cover: b.Cover,
DownloadURL: b.DownloadURL,
Rank: b.Rank,
Material: b.Material,
New: b.New,
Tags: b.Tags,
MTime: b.MTime,
})
}
}
basicMap["subs"] = subs
basicMap["fons"] = fons
basicMap["hots"] = hots
basicMap["stis"] = stis
basicMap["ints"] = ints
basicMap["trans"] = trans
basicMap["themes"] = themes
return
}
// CategoryBind fn
func (d *Dao) CategoryBind(c context.Context, tp int8) (res []*music.MaterialBind, err error) {
res = make([]*music.MaterialBind, 0)
rows, err := d.db.Query(c, fmt.Sprintf(_CategoryBindSQL, tp))
if err != nil {
log.Error("mysqlDB.Query error(%v)", err)
return
}
defer rows.Close()
for rows.Next() {
v := &music.MaterialBind{}
if err = rows.Scan(&v.New, &v.Tp, &v.CName, &v.CRank, &v.BRank, &v.MID, &v.CID); err != nil {
log.Error("row.Scan error(%v)", err)
return
}
res = append(res, v)
}
return
}
// Filters fn
func (d *Dao) Filters(c context.Context) (res []*music.Filter, resMap map[int64]*music.Filter, err error) {
res = make([]*music.Filter, 0)
resMap = make(map[int64]*music.Filter)
rows, err := d.db.Query(c, _FiltersSQL)
if err != nil {
log.Error("mysqlDB.Query error(%v)", err)
return
}
defer rows.Close()
for rows.Next() {
v := &music.Filter{
Material: music.Material{},
}
if err = rows.Scan(&v.MTime, &v.ID, &v.Name, &v.Rank, &v.Extra, &v.Material.Platform, &v.Material.Build); err != nil {
log.Error("row.Scan error(%v)", err)
return
}
var extra *struct {
Cover string `json:"cover"`
DownloadURL string `json:"download_url"`
TagsStr string `json:"tags"`
FilterType int8 `json:"filter_type"`
}
if err = json.Unmarshal([]byte(v.Extra), &extra); err != nil {
log.Error("json.Unmarshal failed error(%v)", err)
continue
}
v.Cover = extra.Cover
v.DownloadURL = extra.DownloadURL
v.FilterType = extra.FilterType
if len(v.Material.Build) > 0 {
var buildComps []*music.BuildComp
if err = json.Unmarshal([]byte(v.Build), &buildComps); err != nil {
log.Error("json.Unmarshal buildComps failed error(%v)", err)
continue
}
v.Material.BuildComps = buildComps
}
if v.MTime.Time().AddDate(0, 0, 7).Unix() >= time.Now().Unix() {
v.New = 1
}
if len(extra.TagsStr) > 0 {
v.Tags = append(v.Tags, strings.Split(extra.TagsStr, ",")...)
}
log.Info("v info v(%+v)", v)
res = append(res, v)
resMap[v.ID] = v
}
return
}
// Vstickers fn
func (d *Dao) Vstickers(c context.Context) (res []*music.VSticker, resMap map[int64]*music.VSticker, err error) {
res = make([]*music.VSticker, 0)
resMap = make(map[int64]*music.VSticker)
rows, err := d.db.Query(c, _VstickersSQL)
if err != nil {
log.Error("mysqlDB.Query error(%v)", err)
return
}
defer rows.Close()
for rows.Next() {
v := &music.VSticker{
Material: music.Material{},
}
if err = rows.Scan(&v.MTime, &v.ID, &v.Name, &v.Rank, &v.Extra, &v.Material.Platform, &v.Material.Build); err != nil {
log.Error("row.Scan error(%v)", err)
return
}
var extra *struct {
Cover string `json:"cover"`
DownloadURL string `json:"download_url"`
TagsStr string `json:"tags"`
}
if err = json.Unmarshal([]byte(v.Extra), &extra); err != nil {
log.Error("json.Unmarshal failed error(%v)", err)
continue
}
v.Cover = extra.Cover
v.DownloadURL = extra.DownloadURL
if len(v.Material.Build) > 0 {
var buildComps []*music.BuildComp
if err = json.Unmarshal([]byte(v.Build), &buildComps); err != nil {
log.Error("json.Unmarshal buildComps failed error(%v)", err)
continue
}
v.Material.BuildComps = buildComps
}
if v.MTime.Time().AddDate(0, 0, 7).Unix() >= time.Now().Unix() {
v.New = 1
}
if len(extra.TagsStr) > 0 {
v.Tags = append(v.Tags, strings.Split(extra.TagsStr, ",")...)
}
log.Info("v info v(%+v)", v)
res = append(res, v)
resMap[v.ID] = v
}
return
}
// Cooperates fn
func (d *Dao) Cooperates(c context.Context) (res []*music.Cooperate, daids []int64, err error) {
res = make([]*music.Cooperate, 0)
rows, err := d.db.Query(c, _CooperatesSQL)
if err != nil {
log.Error("mysqlDB.Query error(%v)", err)
return
}
defer rows.Close()
for rows.Next() {
v := &music.Cooperate{
Material: music.Material{},
}
if err = rows.Scan(&v.MTime, &v.ID, &v.Name, &v.Rank, &v.Extra, &v.Material.Platform, &v.Material.Build); err != nil {
log.Error("row.Scan error(%v)", err)
return
}
var extra *struct {
Cover string `json:"cover"`
MaterialAID int64 `json:"material_aid"`
MaterialCID int64 `json:"material_cid"`
DemoAID int64 `json:"demo_aid"`
DemoCID int64 `json:"demo_cid"`
MissionID int64 `json:"mission_id"`
TagsStr string `json:"tags"`
SubType int `json:"sub_type"`
Style int `json:"style"`
DownloadURL string `json:"download_url"`
}
if err = json.Unmarshal([]byte(v.Extra), &extra); err != nil {
log.Error("json.Unmarshal failed error(%v)", err)
continue
}
daids = append(daids, extra.MaterialAID)
v.Cover = extra.Cover
v.MaterialAID = extra.MaterialAID
v.MaterialCID = extra.MaterialCID
v.DemoAID = extra.DemoAID
v.DemoCID = extra.DemoCID
v.MissionID = extra.MissionID
v.SubType = extra.SubType
v.Style = extra.Style
v.DownloadURL = extra.DownloadURL
if len(v.Material.Build) > 0 {
var buildComps []*music.BuildComp
if err = json.Unmarshal([]byte(v.Build), &buildComps); err != nil {
log.Error("json.Unmarshal buildComps failed error(%v)", err)
continue
}
v.Material.BuildComps = buildComps
}
if v.MTime.Time().AddDate(0, 0, 7).Unix() >= time.Now().Unix() {
v.New = 1
}
if len(extra.TagsStr) > 0 {
v.Tags = append(v.Tags, strings.Split(extra.TagsStr, ",")...)
}
log.Info("v info v(%+v)", v)
res = append(res, v)
}
return
}