You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
385 lines
11 KiB
385 lines
11 KiB
package danmu |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"go-common/app/interface/main/creative/model/danmu" |
|
pubSvc "go-common/app/interface/main/creative/service" |
|
dmMdl "go-common/app/interface/main/dm/model" |
|
"go-common/app/service/main/account/model" |
|
account "go-common/app/service/main/account/model" |
|
"go-common/app/service/main/archive/api" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
"go-common/library/sync/errgroup" |
|
"strconv" |
|
"time" |
|
) |
|
|
|
var ( |
|
stateMap = map[int8]int8{ |
|
0: 0, // 正常 |
|
1: 1, // 删除 |
|
2: 2, // 保护 |
|
3: 3, // 取消保护 |
|
} |
|
poolMap = map[int8]int8{ |
|
0: 0, // 普通弹幕池 |
|
1: 1, // 字幕弹幕池 |
|
2: 2, // 特殊弹幕池 |
|
} |
|
) |
|
|
|
// AdvDmPurchaseList fn |
|
func (s *Service) AdvDmPurchaseList(c context.Context, mid int64, ip string) (danmus []*danmu.AdvanceDanmu, err error) { |
|
if danmus, err = s.dm.GetAdvDmPurchases(c, mid, ip); err != nil { |
|
log.Error("s.dm.ListAdvDmPurchases err(%v) | mid(%d), ip(%s)", err, mid, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// PassDmPurchase fn |
|
func (s *Service) PassDmPurchase(c context.Context, mid, id int64, ip string) (err error) { |
|
if err = s.dm.PassAdvDmPurchase(c, mid, id, ip); err != nil { |
|
log.Error("s.dm.PassDmPurchase err(%v) | mid(%d), id(%d), ip(%s)", err, mid, id, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// DenyDmPurchase fn |
|
func (s *Service) DenyDmPurchase(c context.Context, mid, id int64, ip string) (err error) { |
|
if err = s.dm.DenyAdvDmPurchase(c, mid, id, ip); err != nil { |
|
log.Error("s.dm.DenyDmPurchase err(%v) | mid(%d), id(%d), ip(%s)", err, mid, id, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// CancelDmPurchase fn |
|
func (s *Service) CancelDmPurchase(c context.Context, mid, id int64, ip string) (err error) { |
|
if err = s.dm.CancelAdvDmPurchase(c, mid, id, ip); err != nil { |
|
log.Error("s.dm.CancelDmPurchase err(%v) | mid(%d), id(%d), ip(%s)", err, mid, id, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// Edit fn |
|
func (s *Service) Edit(c context.Context, mid, id int64, state int8, dmids []int64, ip string) (err error) { |
|
if len(dmids) == 0 { |
|
err = ecode.CreativeDanmuFilterParamError |
|
return |
|
} |
|
okState := false |
|
for _, v := range stateMap { |
|
if v == state { |
|
okState = true |
|
} |
|
} |
|
if !okState { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
if err = s.dm.Edit(c, mid, id, state, dmids, ip); err != nil { |
|
log.Error("s.dm.DmList err(%v)|mid(%d),id(%d),state(%d),dmids(%+v),ip(%s)", err, mid, id, state, dmids, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// Transfer fn |
|
func (s *Service) Transfer(c context.Context, mid, fromCID, toCID int64, offset float64, ak, ck, ip string) (err error) { |
|
if err = s.dm.Transfer(c, mid, fromCID, toCID, offset, ak, ck, ip); err != nil { |
|
log.Error("s.dm.Transfer err(%v) | mid(%d),fromCID(%d),toCID(%d),offset(%+v),ak(%s),ck(%s),ip(%s)", err, mid, fromCID, toCID, offset, ak, ck, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// UpPool fn |
|
func (s *Service) UpPool(c context.Context, cid int64, dmids []int64, pool int8, mid int64, ip string) (err error) { |
|
okPool := false |
|
for _, v := range poolMap { |
|
if v == pool { |
|
okPool = true |
|
} |
|
} |
|
if !okPool { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
if err = s.dm.UpPool(c, mid, cid, dmids, pool); err != nil { |
|
log.Error("s.dm.UpPool err(%v)|cid(%d),dmids(%+v),pool(%+v),mid(%d),ip(%s)", err, cid, dmids, pool, mid, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// Distri fn |
|
func (s *Service) Distri(c context.Context, mid, cid int64, ip string) (dmDistri map[int64]int64, err error) { |
|
if dmDistri, err = s.dm.Distri(c, mid, cid, ip); err != nil { |
|
log.Error("s.dm.Distri err(%v) | mid(%d),cid(%d)|ip(%s)", err, mid, cid, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// List fn |
|
func (s *Service) List(c context.Context, mid, aid, cid int64, pn, ps int, order, pool, midStr, ip string) (dmList *danmu.DmList, err error) { |
|
var ( |
|
v *api.Page |
|
a *api.Arc |
|
mids []int64 |
|
elecs map[int64]int |
|
followers map[int64]int |
|
senders map[int64]*account.Info |
|
) |
|
a, _ = s.arc.Archive(c, aid, ip) |
|
v, _ = s.arc.Video(c, aid, cid, ip) |
|
if dmList, err = s.dm.List(c, cid, mid, pn, ps, order, pool, midStr, ip); err != nil { |
|
log.Error("s.dm.List err(%v) | mid(%d), cid(%d),pn(%d),ps(%d),order(%s),midStr(%s),ip(%s)", err, mid, cid, pn, ps, order, midStr, ip) |
|
return |
|
} |
|
for _, l := range dmList.List { |
|
mids = append(mids, l.Mid) |
|
} |
|
if len(mids) > 0 { |
|
var g, ctx = errgroup.WithContext(c) |
|
g.Go(func() error { //获取被充电状态 |
|
elecs, _ = s.elec.ElecRelation(ctx, mid, mids, ip) |
|
return nil |
|
}) |
|
g.Go(func() error { //获取用户信息 |
|
senders, _ = s.acc.Infos(ctx, mids, ip) |
|
return nil |
|
}) |
|
g.Go(func() error { //获取被关注状态 |
|
followers, _ = s.acc.Followers(ctx, mid, mids, ip) |
|
return nil |
|
}) |
|
g.Wait() |
|
for _, l := range dmList.List { |
|
l.VTitle = v.Part |
|
l.ArcTitle = a.Title |
|
l.Aid = aid |
|
l.Cover = pubSvc.CoverURL(a.Pic) |
|
if elec, ok := elecs[l.Mid]; ok { //设置充电状态 |
|
l.IsElec = elec |
|
} |
|
if u, ok := senders[l.Mid]; ok { //设置图像和用户名 |
|
l.Uname = u.Name |
|
l.Uface = u.Face |
|
} |
|
if relation, ok := followers[l.Mid]; ok { //设置关注状态 |
|
l.Relation = relation |
|
} |
|
} |
|
} |
|
return |
|
} |
|
|
|
// Recent fn |
|
func (s *Service) Recent(c context.Context, mid, pn, ps int64, ip string) (dmRecent *danmu.DmRecent, err error) { |
|
var ( |
|
aids []int64 |
|
mids []int64 |
|
elecs map[int64]int |
|
followers map[int64]int |
|
senders map[int64]*account.Info |
|
) |
|
if dmRecent, aids, err = s.dm.Recent(c, mid, pn, ps, ip); err != nil { |
|
log.Error("s.dm.Recent err(%v)|(%v),(%v),(%v),(%v),", err, mid, pn, ps, ip) |
|
return |
|
} |
|
if len(dmRecent.List) > 0 && len(aids) > 0 { |
|
var avm map[int64]*api.Arc |
|
if avm, err = s.arc.Archives(c, aids, ip); err != nil { |
|
log.Error("s.arc.Archives mid(%d)|aids(%+v)|ip(%s)|err(%v)", mid, aids, ip, err) |
|
err = nil |
|
} |
|
for _, l := range dmRecent.List { |
|
mids = append(mids, l.Mid) |
|
} |
|
var g, ctx = errgroup.WithContext(c) |
|
g.Go(func() error { //获取被充电状态 |
|
elecs, _ = s.elec.ElecRelation(ctx, mid, mids, ip) |
|
return nil |
|
}) |
|
g.Go(func() error { //获取用户信息 |
|
senders, _ = s.acc.Infos(ctx, mids, ip) |
|
return nil |
|
}) |
|
g.Go(func() error { //获取被关注状态 |
|
followers, _ = s.acc.Followers(ctx, mid, mids, ip) |
|
return nil |
|
}) |
|
g.Wait() |
|
for _, l := range dmRecent.List { |
|
if av, ok := avm[l.Aid]; ok && av != nil { |
|
l.Cover = pubSvc.CoverURL(av.Pic) |
|
} |
|
if elec, ok := elecs[l.Mid]; ok { //设置充电状态 |
|
l.IsElec = elec |
|
} |
|
if u, ok := senders[l.Mid]; ok { //设置图像和用户名 |
|
l.Uname = u.Name |
|
l.Uface = u.Face |
|
} |
|
if relation, ok := followers[l.Mid]; ok { //设置关注状态 |
|
l.Relation = relation |
|
} |
|
} |
|
} |
|
return |
|
} |
|
|
|
// DmReportCheck fn |
|
func (s *Service) DmReportCheck(c context.Context, mid, cid, dmid, op int64, ip string) (err error) { |
|
if err = s.dm.ReportUpEdit(c, mid, dmid, cid, op, ip); err != nil { |
|
log.Error("s.dm.ReportUpEdit err(%v) | mid(%d), dmid(%d),cid(%d),op(%d),ip(%s)", err, mid, dmid, cid, op, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// DmProtectArchive fn |
|
func (s *Service) DmProtectArchive(c context.Context, mid int64, ip string) (vlist []*dmMdl.Video, err error) { |
|
if vlist, err = s.dm.ProtectApplyVideoList(c, mid, ip); err != nil { |
|
log.Error("s.dm.ProtectApplyVideoList err(%v) | mid(%d),ip(%s)", err, mid, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// DmProtectList fn |
|
func (s *Service) DmProtectList(c context.Context, mid int64, page int64, aidStr, sort, ip string) (list *danmu.ApplyList, err error) { |
|
if list, err = s.dm.ProtectApplyList(c, mid, page, aidStr, sort, ip); err != nil { |
|
log.Error("s.dm.ProtectApplyList err(%v) | mid(%d),aidStr(%s),page(%d),sort(%s),ip(%s)", err, mid, aidStr, page, sort, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// DmProtectOper fn |
|
func (s *Service) DmProtectOper(c context.Context, mid, status int64, idsStr, ip string) (err error) { |
|
if err = s.dm.ProtectOper(c, mid, status, idsStr, ip); err != nil { |
|
log.Error("s.dm.ProtectOper err(%v) | mid(%d), status(%d),ids(%s),ip(%s)", err, mid, status, idsStr, ip) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// UserMid for dm search by name |
|
func (s *Service) UserMid(c context.Context, name, ip string) (mid int64, err error) { |
|
if mid, err = s.acc.MidByName(c, name); err != nil { |
|
log.Error("UserMid err(%v) | name(%s), ip(%s)", err, name, ip) |
|
if err == ecode.AccountInexistence { |
|
err = nil |
|
} |
|
return |
|
} |
|
return |
|
} |
|
|
|
// DmReportList fn |
|
func (s *Service) DmReportList(c context.Context, mid, pn, ps int64, aidStr, ip string) (res map[string]interface{}, err error) { |
|
var ( |
|
pager = map[string]int64{ |
|
"total": 0, |
|
"current": pn, |
|
"size": ps, |
|
} |
|
list = []*danmu.DmReport{} |
|
srchs = []*dmMdl.RptSearch{} |
|
ars = []*danmu.DmArc{} |
|
total = int64(0) |
|
owners = []int64{} |
|
) |
|
res = map[string]interface{}{ |
|
"pager": pager, |
|
"list": list, |
|
"archives": ars, |
|
} |
|
if srchs, total, err = s.dm.ReportUpList(c, mid, pn, ps, aidStr, ip); err != nil { |
|
log.Error("s.dm.ReportUpList err(%v) | mid(%d),pn(%d),ps(%d),aidStr(%s),ip(%s)", err, mid, pn, ps, aidStr, ip) |
|
return |
|
} |
|
if len(srchs) > 0 { |
|
for _, v := range srchs { |
|
owners = append(owners, v.Owner) |
|
} |
|
var ownerProfiles map[int64]*model.Info |
|
if ownerProfiles, err = s.acc.Infos(c, owners, ip); err != nil { |
|
log.Error("s.cc.Infos err(%v) | mid(%d),pn(%d),ps(%d),aidStr(%s),ip(%s)", err, mid, pn, ps, aidStr, ip) |
|
return |
|
} |
|
for _, s := range srchs { |
|
t, _ := time.ParseInLocation("2006-01-02 15:04:05", s.RpTime, time.Local) |
|
report := &danmu.DmReport{ |
|
RpID: s.ID, |
|
DmInID: s.Cid, |
|
AID: s.Aid, |
|
Pic: pubSvc.CoverURL(s.Cover), |
|
ReportTime: t.Unix(), |
|
Title: s.Title, |
|
Reason: s.Content, |
|
DmID: s.Did, |
|
DmIDStr: strconv.FormatInt(s.Did, 10), |
|
UpUID: s.UPUid, |
|
Content: s.Msg, |
|
UID: s.Owner, |
|
} |
|
if profile, ok := ownerProfiles[s.Owner]; ok { |
|
report.UserName = profile.Name |
|
} |
|
list = append(list, report) |
|
} |
|
if ars, err = s.dm.ReportUpArchives(c, mid, ip); err != nil { |
|
log.Error("s.dm.ReportUpArchives err(%v) | mid(%d),ip(%s)", err, mid, ip) |
|
return |
|
} |
|
} |
|
pager["total"] = total |
|
res["pager"] = pager |
|
res["list"] = list |
|
res["archives"] = ars |
|
return |
|
} |
|
|
|
// EditBatch fn |
|
func (s *Service) EditBatch(c context.Context, mid int64, paramsJSON, ip string) (err error) { |
|
type P struct { |
|
CID int64 `json:"cid"` |
|
DmID int64 `json:"dmid"` |
|
State int8 `json:"state"` |
|
} |
|
var filtersJSONData []*P |
|
if err = json.Unmarshal([]byte(paramsJSON), &filtersJSONData); err != nil { |
|
err = ecode.RequestErr |
|
return |
|
} |
|
if len(filtersJSONData) == 0 { |
|
err = ecode.CreativeDanmuFilterParamError |
|
return |
|
} |
|
var ( |
|
g errgroup.Group |
|
) |
|
for _, v := range filtersJSONData { |
|
dmids := []int64{} |
|
dmids = append(dmids, v.DmID) |
|
cid := v.CID |
|
state := v.State |
|
g.Go(func() (err error) { |
|
if err = s.dm.Edit(c, mid, cid, state, dmids, ip); err != nil { |
|
log.Error("s.d.Edit v(%+v)|dmids(%+v)|cid(%+v)|state(%+v)|err(%+v)", v, dmids, cid, state, err) |
|
} |
|
log.Info("filtersJSONData v(%+v)|dmids(%+v)|cid(%+v)|state(%+v)|err(%+v)", v, dmids, cid, state, err) |
|
return |
|
}) |
|
} |
|
g.Wait() |
|
return |
|
}
|
|
|